{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- By: Oleksandr Proskurin\n",
    "- Email: proskurinolexandr@gmail.com\n",
    "- Reference: Advances in Financial Machine Learning, Marcos Lopez De Prado, pg 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ETF trick use case. SPX/EuroStoxx hedging implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how mlfinlab etf trick is used to solve the exercise 2.3 from Chapter 2. For this exercise we use daily SPY and EUROSTOXX futures data and EUR/USD exchange rates from https://www.investing.com/. Hedging weights are recalculated on a daily basis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imports\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import datetime as dt\n",
    "from mlfinlab.multi_product.etf_trick import ETFTrick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_cov_mat(row):\n",
    "    \"\"\"\n",
    "    Forms covariance matrix from current data frame row using 'rolling_cov', \n",
    "    'rolling_spx_var' and 'rolling_eur_var' column values\n",
    "    \"\"\"\n",
    "    cov = row['rolling_cov']\n",
    "    spx_var = row['rolling_spx_var']\n",
    "    euro_var = row['rolling_euro_var']\n",
    "    return np.matrix([[spx_var, cov], [cov, euro_var]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Snippet 2.1 from a book\n",
    "def pca_weights(cov, riskDist=None, risk_target = 1.):\n",
    "    \"\"\"\n",
    "    Calculates hedging weights using covariance matrix(cov), risk distribution(riskDist) and risk_target\n",
    "    \"\"\"\n",
    "    eVal, eVec = np.linalg.eigh(cov)\n",
    "    indices = eVal.argsort()[::-1]\n",
    "    eVal, eVec = eVal[indices], eVec[:, indices]\n",
    "    if riskDist is None:\n",
    "        riskDist = np.zeros(cov.shape[0])\n",
    "        riskDist[-1] = 1.\n",
    "    loads = risk_target * (riskDist/eVal)**.5\n",
    "    wghts = np.dot(eVec, np.reshape(loads, (-1,1)))\n",
    "    return wghts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "spx = pd.read_csv('../Sample-Data/spx.csv', usecols=['Date', 'Price', 'Open'])\n",
    "euro = pd.read_csv('../Sample-Data/eurostoxx.csv', usecols=['Date', 'Price', 'Open'])\n",
    "eur_usd = pd.read_csv('../Sample-Data/eur_usd.csv', usecols = ['Date', 'Price'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rename columns to universal format\n",
    "spx.rename(columns = {'Date': 'date', 'Price': 'close', 'Open': 'open'}, inplace=True) \n",
    "euro.rename(columns = {'Date': 'date', 'Price': 'close', 'Open': 'open'}, inplace=True)\n",
    "eur_usd.rename(columns = {'Date': 'date', 'Price': 'close'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "spx['date'] = pd.to_datetime(spx.date) #convert date column to datetime format\n",
    "euro['date'] = pd.to_datetime(euro.date)\n",
    "eur_usd['date'] = pd.to_datetime(eur_usd.date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert price data from strings to float (investing.com uses specific decimal sep format)\n",
    "spx.close = spx.close.apply(lambda x: x.replace(',', '')).astype(float)\n",
    "euro.close = euro.close.apply(lambda x: x.replace(',', '')).astype(float)\n",
    "spx.open = spx.open.apply(lambda x: x.replace(',', '')).astype(float)\n",
    "euro.open = euro.open.apply(lambda x: x.replace(',', '')).astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "spx.set_index('date', inplace=True)\n",
    "euro.set_index('date', inplace=True)\n",
    "eur_usd.set_index('date', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "spx.sort_index(inplace=True)\n",
    "euro.sort_index(inplace=True)\n",
    "eur_usd.sort_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "eur_usd = eur_usd[eur_usd.index.isin(spx.index)] # exchange rate is needed only for dates when futures are traded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate covariances and hedging weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cov_df = pd.DataFrame(index=spx.index) # init data frame with covariance and price data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "cov_df.loc[spx.index, 'spx_close'] = spx.loc[:, 'close']\n",
    "cov_df.loc[euro.index, 'euro_close'] = euro.loc[:, 'close']\n",
    "cov_df.loc[spx.index, 'spx_open'] = spx.loc[:, 'open']\n",
    "cov_df.loc[euro.index, 'euro_open'] = euro.loc[:, 'open']\n",
    "cov_df.loc[eur_usd.index, 'eur_usd'] = eur_usd.loc[:, 'close']\n",
    "cov_df['euro_fx_adj'] = cov_df.euro_close / cov_df.eur_usd # we need to calculate EUROSTOXX returns adjusted for FX rate\n",
    "cov_df['spx'] = cov_df.spx_close.pct_change().fillna(0)\n",
    "cov_df['euro'] = cov_df.euro_fx_adj.pct_change().fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill missing values with previous ones\n",
    "cov_df.update(cov_df.loc[:, ['spx', 'euro', 'spx_close', 'spx_open', 'euro_close', 'euro_open', 'eur_usd']].fillna(method='pad'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "cov_df.sort_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get 252 rolling covariance between SPY and EUROSTOXX, rolling variances\n",
    "cov_df['rolling_cov'] = cov_df['spx'].rolling(window=252).cov(cov_df['euro']) \n",
    "cov_df['rolling_spx_var'] = cov_df['spx'].rolling(window=252).var()\n",
    "cov_df['rolling_euro_var'] = cov_df['euro'].rolling(window=252).var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iterate over cov_df and on each step define hedging weights using pca_weights function\n",
    "cov_df.dropna(inplace=True)\n",
    "for index, row in cov_df.iterrows():\n",
    "    mat = generate_cov_mat(row)\n",
    "    w = pca_weights(mat)\n",
    "    cov_df.loc[index, 'spx_w'] = w[0]\n",
    "    cov_df.loc[index, 'euro_w'] = w[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare data set for ETF trick"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ETFTrick class requires open_df, close_df, alloc_df, costs_df, rates_df. Each of these data frames should be in  a specific format:\n",
    "\n",
    "    1) DateTime index\n",
    "    2) Each column name corresponds to a ticker, number of columns in all data frames should be equal.In our case all   data frames contain columns: 'spx' and 'euro'. \n",
    "    For example, we implement etf trick with 5 securities: A, B, C, D, E. If for the first two years only A, B and C close data is available while for the last two years only D and E data is available, close data frame format will be:\n",
    "    index        A    B     C     D     E\n",
    "    Year 1      22.0 7.52  7.5   NaN   NaN\n",
    "    Year 1      20.7 7.96  8.2   NaN   NaN\n",
    "    .....\n",
    "    Year N      NaN  NaN   NaN   0.3   100.5\n",
    "   \n",
    "__open_df__: _open prices (in contract currency)_\n",
    "\n",
    "__close_df__: _close prices_\n",
    "\n",
    "__alloc_df__: _securities allocation vector_\n",
    "\n",
    "__costs_df__: _costs of holding/rebalancing the position_\n",
    "\n",
    "__rates_df__: _$ value of 1 point move of contract price. This includes exchange rates, futures multipliers_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alex/miniconda3/envs/research/lib/python3.7/site-packages/pandas/core/frame.py:4025: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  return super(DataFrame, self).rename(**kwargs)\n"
     ]
    }
   ],
   "source": [
    "open_df = cov_df[['spx_open', 'euro_open']] # create open_df\n",
    "open_df.rename(columns = {'spx_open': 'spx', 'euro_open': 'euro'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "close_df = cov_df[['spx_close', 'euro_close']] # create close_df\n",
    "close_df.rename(columns = {'spx_close': 'spx', 'euro_close': 'euro'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "rates_df = 1/cov_df[['eur_usd']] # we need USD_EUR = 1/EUR_USD rate for EUROSTOXX price movements\n",
    "rates_df.rename(columns = {'eur_usd': 'euro'}, inplace=True)\n",
    "rates_df['spx'] = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "alloc_df = cov_df[['spx_w', 'euro_w']] # allocations data frame with weights generated using pca_weights()\n",
    "alloc_df.rename(columns={'spx_w': 'spx', 'euro_w': 'euro'}, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "costs_df = alloc_df.copy() # let's assume zero rebalancing costs\n",
    "costs_df['spx'] = 0.0\n",
    "costs_df['euro'] = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "trick = ETFTrick(open_df, close_df, alloc_df,\n",
    "                costs_df, rates_df, in_memory=True) # in_memory means that all data frames are stored in memory, if False open_df should be a path to open data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "trick_series = trick.get_etf_series()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7febbf74a320>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trick_series.plot()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:research] *",
   "language": "python",
   "name": "conda-env-research-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
